package internal

import (
	"GameServer/Common/data"
	"GameServer/Common/utils"
	"GameServer/Game/dbmodule"
	"GameServer/Game/lib"
	"GameServer/Game/m"

	log "github.com/sirupsen/logrus"
)

// 委托活动
type EntrustActiv struct {
	Activ *m.EAActiv
}

func NewEntrustActiv() *EntrustActiv {
	return &EntrustActiv{}
}

func (this *EntrustActiv) Init() {
	this.Activ = m.GetEAActiv(1)
	this.CheckActiv()
}

func (this *EntrustActiv) Run(closeSig chan bool) {

}

func (this *EntrustActiv) Destroy() {

}

func (this *EntrustActiv) CheckActiv() {
	// 加载委托活动
	activ, err := lib.GetCurrentEntrustActiv()
	if err != nil {
		// 没有委托活动，委托活动结束。
		log.WithFields(log.Fields{
			"method": "CheckActiv",
		}).Error("没有委托活动开启，或委托活动结束")
		this.DelActiv()
		return
	}
	// 有委托活动，正在执行
	if this.Activ.ActivId == int64(activ.Id) {
		// 当前委托任务id等于缓存活动id，表示当前委托任务正在执行。
		log.WithFields(log.Fields{
			"method":  "CheckActiv",
			"ActivId": activ.Id,
		}).Info("当前委托任务正在执行")
		// 有委托活动，正在执行，凌晨时，切换任务
		now := utils.TNow()
		hour := now.Hour()
		minute := now.Minute()
		// 凌晨时间，切换委托任务
		if hour == 0 && minute == 0 {
			this.ChangeTask()
		}
	} else {
		// 当前委托任务id不等于缓存活动id，表示当前委托任务还没执行。
		// 有委托活动，没有执行，需要加载
		this.LoadActiv(activ)
	}
}

func (this *EntrustActiv) LoadActiv(activ data.EntrustActiv) {
	// 获取委托任务
	task, err := lib.GetEntrustTask(int64(activ.TaskIdLst[0]))
	if err != nil {
		log.WithFields(log.Fields{
			"method": "LoadActiv",
			"err":    err,
		}).Error("获取委托任务失败")
		return
	}

	beginTime, _ := utils.LayoutToTime(activ.BeginTime)
	endTime, _ := utils.LayoutToTime(activ.EndTime)

	act := &m.EAActiv{
		Uid:        1,
		ActivId:    int64(activ.Id),
		BeginTime:  beginTime.Unix(),
		EndTime:    endTime.Unix(),
		RankReward: int64(activ.RankReward),
	}
	act.TaskLst = make([]int64, 0)
	for _, item := range activ.TaskIdLst {
		act.TaskLst = append(act.TaskLst, int64(item))
	}
	act.Update(act)
	this.Activ = act

	allUser := make([]*m.User, 0)
	err = dbmodule.MgoDB.GameDB.FindAll("user", nil, nil, &allUser)
	if err != nil {
		log.WithFields(log.Fields{
			"method": "LoadActiv",
			"err":    err,
		}).Error("查找所有用户失败")
		return
	}

	// 委托任务数量
	taskNum := len(act.TaskLst)
	// 给每一个玩家添加任务
	for _, item := range allUser {
		// 玩家委托活动信息
		gamer := &m.EAGamer{
			Uid:         item.Uid,
			Name:        item.Name,
			Head:        item.Head,
			AvatarFrame: item.AvatarFrame,
			Tid:         act.ActivId,
			BeginTime:   act.BeginTime,
			EndTime:     act.EndTime,
			HonorLst:    make([]int64, taskNum),
		}
		// 委托任务
		gamer.EntrTask = &m.EntrustTask{
			Tid:          int64(task.Id),
			TypeNum:      int64(task.TypeEnum),
			ActionEnum:   int64(task.ActionEnum),
			IntegralUnit: int64(task.IntegralUnit),
			UnitNum:      int64(task.UnitNum),
		}
		// 委托任务奖励
		stageLst := make([]*m.Stage, 0)
		for _, item := range task.Rewards {
			stage := &m.Stage{
				StageVal: int64(item.Id),
				GoodTid:  int64(item.Key),
				GoodNum:  int64(item.Value),
			}
			stageLst = append(stageLst, stage)
		}
		gamer.EntrTask.StageLst = stageLst

		gamer.Update(gamer)
	}
}

func (this *EntrustActiv) ChangeTask() {
	// 获取所有委托用户的uid
	allGamer := make([]*m.EAGamer, 0)
	err := dbmodule.MgoDB.GameDB.FindAll("EAGamer", nil, nil, &allGamer)
	if err != nil {
		log.WithFields(log.Fields{
			"method": "ChangeTask",
			"err":    err,
		}).Error("查找所有用户失败")
		return
	}
	this.Activ.Issue++
	if this.Activ.Issue >= int64(len(this.Activ.TaskLst)) {
		log.WithFields(log.Fields{
			"method": "ChangeTask",
			"Issue":  this.Activ.Issue,
		}).Error("期数超过期次")
		return
	}
	// 获取当前期次委托任务
	task, err := lib.GetEntrustTask(this.Activ.TaskLst[this.Activ.Issue])
	if err != nil {
		log.WithFields(log.Fields{
			"method": "ChangeTask",
			"err":    err,
		}).Error("获取委托任务失败")
		return
	}
	this.Activ.Update(this.Activ)

	// 每个玩家切换任务
	for _, item := range allGamer {
		gamer := m.GetEAGamer(item.Uid.Hex())
		// 委托任务
		gamer.EntrTask = &m.EntrustTask{
			Tid:          int64(task.Id),
			TypeNum:      int64(task.TypeEnum),
			ActionEnum:   int64(task.ActionEnum),
			IntegralUnit: int64(task.IntegralUnit),
			UnitNum:      int64(task.UnitNum),
		}
		// 委托任务奖励
		stageLst := make([]*m.Stage, 0)
		for _, item := range task.Rewards {
			stage := &m.Stage{
				StageVal: int64(item.Id),
				GoodTid:  int64(item.Key),
				GoodNum:  int64(item.Value),
			}
			stageLst = append(stageLst, stage)
		}
		gamer.EntrTask.StageLst = stageLst
		// 切换委托期次
		gamer.Issue = this.Activ.Issue

		gamer.Update(gamer)
	}
}

// 删除活动
func (this *EntrustActiv) DelActiv() {
	activ := &m.EAActiv{Uid: 1}
	activ.Update(activ)
	this.Activ = activ
}
